load_detected_versions() {
    need python3

    eval "$(python3 - "$ROOT_DIR" <<'PY'
import ast
import pathlib
import shlex
import sys

try:
    import tomllib
except ModuleNotFoundError as exc:
    raise SystemExit("python3 with tomllib is required") from exc

root = pathlib.Path(sys.argv[1])


def load_toml(path):
    with path.open("rb") as f:
        return tomllib.load(f)


def shell_var(name, value):
    if not value:
        raise SystemExit(f"missing value for {name}")
    print(f"{name}={shlex.quote(str(value))}")


def package_version(path):
    data = load_toml(path)
    return data["package"]["version"]


def pyproject_version(path):
    data = load_toml(path)
    return data["project"]["version"]


def python_init_version(path):
    tree = ast.parse(path.read_text())
    for node in tree.body:
        if not isinstance(node, ast.Assign):
            continue
        for target in node.targets:
            if isinstance(target, ast.Name) and target.id == "__version__":
                if isinstance(node.value, ast.Constant) and isinstance(node.value.value, str):
                    return node.value.value
    raise SystemExit(f"missing __version__ assignment in {path}")


def chart_top_level(path, key):
    prefix = f"{key}:"
    for line in path.read_text().splitlines():
        if line.startswith((" ", "\t", "#")):
            continue
        stripped = line.strip()
        if stripped.startswith(prefix):
            return stripped.split(":", 1)[1].strip().strip("\"'")
    raise SystemExit(f"missing {key} in {path}")


sdk_rust = load_toml(root / "sdk/rust/Cargo.toml")
stdng_dep = sdk_rust["dependencies"]["stdng"]
macros_dep = sdk_rust["dependencies"]["flame-rs-macros"]

shell_var("DETECTED_PYPROJECT_VERSION", pyproject_version(root / "sdk/python/pyproject.toml"))
shell_var("DETECTED_PYTHON_INIT_VERSION", python_init_version(root / "sdk/python/src/flamepy/__init__.py"))
shell_var("DETECTED_FLAME_RS_VERSION", package_version(root / "sdk/rust/Cargo.toml"))
shell_var("DETECTED_FLAME_RS_MACROS_VERSION", package_version(root / "sdk/rust/macros/Cargo.toml"))
shell_var("DETECTED_STDNG_VERSION", package_version(root / "stdng/Cargo.toml"))
shell_var("DETECTED_CHART_APP_VERSION", chart_top_level(root / "charts/flame/Chart.yaml", "appVersion"))
shell_var("DETECTED_FLAME_RS_STDNG_DEP_VERSION", stdng_dep.get("version"))
shell_var("DETECTED_FLAME_RS_MACROS_DEP_VERSION", macros_dep.get("version"))
PY
)"
}

inspect_image_manifest() {
    local image="$1"

    MANIFEST_FILE="$(mktemp "${TMPDIR:-/tmp}/flame-release-sanity-manifest.XXXXXX")"

    if command -v docker >/dev/null 2>&1; then
        log "docker buildx imagetools inspect --raw ${image}"
        if docker buildx imagetools inspect --raw "$image" >"$MANIFEST_FILE" 2>/dev/null; then
            check_manifest_platforms "$image" "$MANIFEST_FILE"
            rm -f "$MANIFEST_FILE"
            MANIFEST_FILE=""
            return
        fi
    fi

    if command -v podman >/dev/null 2>&1; then
        log "podman manifest inspect ${image}"
        if podman manifest inspect "$image" >"$MANIFEST_FILE" 2>/dev/null; then
            check_manifest_platforms "$image" "$MANIFEST_FILE"
            rm -f "$MANIFEST_FILE"
            MANIFEST_FILE=""
            return
        fi

        log "podman pull ${image}"
        podman pull "$image" >/dev/null
        log "podman image inspect ${image}"
        podman image inspect "$image" >"$MANIFEST_FILE"
        check_manifest_platforms "$image" "$MANIFEST_FILE"
    elif command -v docker >/dev/null 2>&1; then
        log "docker pull ${image}"
        docker pull "$image" >/dev/null
        log "docker image inspect ${image}"
        docker image inspect "$image" >"$MANIFEST_FILE"
        check_manifest_platforms "$image" "$MANIFEST_FILE"
    else
        fail "podman or docker is required for image manifest checks"
    fi

    rm -f "$MANIFEST_FILE"
    MANIFEST_FILE=""
}